package com.whalehearing.tingyou.common.utils;

/**
 * @author: shensh
 * @Desc:
 * @create: 2024-12-26 15:42
 **/
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;
import java.util.Map;
import java.util.Set;

public class RedisUtil {

    private static JedisPool jedisPool;
    private static ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 配置 Jedis 连接池
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxTotal(200);  // 增加最大连接数
        poolConfig.setMaxIdle(50);    // 增加最大空闲连接数
        poolConfig.setMinIdle(30);    // 增加最小空闲连接数
        poolConfig.setTestOnBorrow(true);  // 每次获取连接时进行有效性检查
        poolConfig.setTestOnReturn(true);  // 每次归还连接时进行有效性检查
        poolConfig.setTestWhileIdle(true); // 空闲时检测连接是否有效
        poolConfig.setMinEvictableIdleTimeMillis(60000);  // 连接最大空闲时间
        poolConfig.setTimeBetweenEvictionRunsMillis(30000);  // 清理空闲连接的时间间隔

        // Redis 连接池的初始化
        jedisPool = new JedisPool(poolConfig, "8.135.238.112", 6379,5000);  //连接到本地 Redis，默认端口 6379
    }

    // 获取 Jedis 实例
    private static Jedis getJedis() {
        return jedisPool.getResource();
    }

    // 关闭 Jedis 实例
    private static void closeJedis(Jedis jedis) {
        if (jedis != null) {
            jedis.close();
        }
    }

    // 设置字符串类型的数据
    public static void set(String key, String value) {
        Jedis jedis = getJedis();
        try {
            jedis.set(key, value);
        } finally {
            closeJedis(jedis);
        }
    }

    // 获取字符串类型的数据
    public static String get(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.get(key);
        } finally {
            closeJedis(jedis);
        }
    }

    // 更新字符串类型的数据
    public static void update(String key, String value) {
        Jedis jedis = getJedis();
        try {
            jedis.set(key, value);
        } finally {
            closeJedis(jedis);
        }
    }

    // 删除数据
    public static void delete(String key) {
        Jedis jedis = getJedis();
        try {
            jedis.del(key);
        } finally {
            closeJedis(jedis);
        }
    }

    // 存储 Hash 数据类型
    public static void setHash(String key, Map<String, String> hash) {
        Jedis jedis = getJedis();
        try {
            jedis.hmset(key, hash);
        } finally {
            closeJedis(jedis);
        }
    }

    // 获取 Hash 数据类型
    public static Map<String, String> getHash(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.hgetAll(key);
        } finally {
            closeJedis(jedis);
        }
    }

    // 存储列表数据类型
    public static void setList(String key, String... values) {
        Jedis jedis = getJedis();
        try {
            jedis.rpush(key, values);
        } finally {
            closeJedis(jedis);
        }
    }

    // 获取列表数据类型
    public static List<String> getList(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.lrange(key, 0, -1);
        } finally {
            closeJedis(jedis);
        }
    }

    // 存储集合数据类型
    public static void setSet(String key, String... values) {
        Jedis jedis = getJedis();
        try {
            jedis.sadd(key, values);
        } finally {
            closeJedis(jedis);
        }
    }

    // 获取集合数据类型
    public static Set<String> getSet(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.smembers(key);
        } finally {
            closeJedis(jedis);
        }
    }

    // 存储有序集合数据类型
    public static void setZSet(String key, Map<String, Double> scoreMembers) {
        Jedis jedis = getJedis();
        try {
            jedis.zadd(key, scoreMembers);
        } finally {
            closeJedis(jedis);
        }
    }

    // 获取有序集合数据类型
    public static Set<String> getZSet(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.zrange(key, 0, -1);
        } finally {
            closeJedis(jedis);
        }
    }

    // 检查某个 key 是否存在
    public static boolean exists(String key) {
        Jedis jedis = getJedis();
        try {
            return jedis.exists(key);
        } finally {
            closeJedis(jedis);
        }
    }

    // 设置 key 的过期时间（单位秒）
    public static void setExpire(String key, int seconds) {
        Jedis jedis = getJedis();
        try {
            jedis.expire(key, seconds);
        } finally {
            closeJedis(jedis);
        }
    }

    // 存储泛型 List 到 Redis，并设置过期时间为一天（86400秒）
    public static <T> void setList(String key, List<T> dataList) {
        Jedis jedis = getJedis();
        try {
            // 将 List<T> 转换为 JSON 字符串
            String json = objectMapper.writeValueAsString(dataList);

            // 存储到 Redis
            jedis.set(key, json);

            // 设置过期时间为一天（86400秒）
            jedis.expire(key, 86400);  // 86400 秒 = 1 天
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
    }

    // 从 Redis 获取泛型 List
    public static <T> List<T> getList(String key, Class<T> clazz) {
        Jedis jedis = getJedis();
        try {
            // 获取 JSON 字符串
            String json = jedis.get(key);

            // 将 JSON 字符串转换为 List<T> 对象
            if (json != null) {
                return objectMapper.readValue(json, objectMapper.getTypeFactory().constructCollectionType(List.class, clazz));
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeJedis(jedis);
        }
        return null;
    }

}


